package ThreadDemo.ThreadDemo1;



/**
 * 创建线程方法一：
 * 继承 Thread
 * 重写 run 方法
 */

public class MyThread extends Thread{


    @Override
    public void run() {
        while (true) {
            System.out.println("MyThread的run线程 正在运行...");
            try {
                MyThread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread =new MyThread();

        // 创建一个线程
        myThread.start();

        // 主方法
        while (true) {

            System.out.println("main线程 正在运行...");
            MyThread.sleep(1000);
        }




    }
}


/**
 * 方法二：
 * 继承 Runnable
 * 实现 run 方法
 *
 */


class  MyThread1 implements  Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("Runnable 中run线程 正在运行...");
            try {
                MyThread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {


        Thread myThread1 = new Thread(new MyThread1());
        myThread1.start();

        // 接口
        while (true) {
            System.out.println("main线程 正在运行");
            MyThread.sleep(1000);
        }


    }
}

/**
 * 方法三 : Runnable 的匿名内部类
 * 在匿名内部类中 实现 Run 方法
 *
 */

 class  MyThread2 {
    public static void main(String[] args) {
        Thread myThread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("内部类Runnable 中 Run方法正在执行...");
                    try {
                        MyThread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }

        });

        // 创建线程
        myThread2.start();

        while (true) {
            System.out.println("主线程方法正在调用....");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

                throw new RuntimeException(e);

            }
        }


    }
}



/**
 *
 * 方法四： Thread 的匿名内部类
 * 在匿名内部类中重写 Run 方法
 *
 */


class  MyThread3 {
    public static void main(String[] args) throws InterruptedException {

        Thread myThread3 = new Thread(){

            @Override
            public void run() {
                while (true) {
                    System.out.println("匿名类 MyThread的run线程 正在运行...");
                    try {
                        MyThread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        // 创建线程
        myThread3.start();

        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            MyThread.sleep(1000);
        }
    }
}


/**
 * 方法五：  使用 lambda 表达式简化 匿名内部类
 *
 */

class  MyThread4 {



    public static void main(String[] args) throws InterruptedException {

        Thread myThread4 = new Thread(()->{
            while (true) {
                System.out.println("lambda 匿名类 MyThread的run线程 正在运行...");
                try {
                    MyThread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        // 创建线程
        myThread4.start();
        myThread4.start();

        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            MyThread.sleep(1000);
        }
    }
}
